IRIX 6.5 Applications 2004 May/SGI IRIX 6.5 Applications 2004 May.iso/dist/desktop_tools.idb/usr/lib/jot/jot.doc.z/jot.doc

Text File | 1998-05-04 | 44.9 KB | 1,333 lines

To find help on a topic, select the topic (easy to
do by double-clicking with the left mouse button),
and then hold down the Alt key and type "f", or
just scroll with the left mouse in the scroll bar.

    Accelerators
    AppendToCutBuffer
    Backups
    BackwardTab
    ChangingCase
    CheckpointFiles
    CommandRemapping
    Ctags
    CutCopyPaste
    DialogBoxes
    DragSelection
    Editing
    ElectricCMode
    ExtendSelection
    Filters
    FilterExamples
    Indentation
    InsertingFiles
    JumpToLineNumber
    LineNumbers
    LongLines
    Macros
    Marks
    NonStandardCharacters
    Notation
    OpeningFiles
    ParenthesisMatching
    PullDownMenu
    Preferences
    QueryReplace
    RedoCommand
    ReformattingParagraphs
    RegularExpressions
    RepeatCounts
    RepeatLastCommand
    ReverseSearch
    ScrollingThroughText
    SearchAndReplace
    SearchMultipleFiles
    SearchingForText
    Selection
    SelectWord
    ShowCutBuffer
    ShowLineNumber
    SpeedKeys
    SplitWindow
    StartupFlags
    Tutorial
    TwoWindows
    TypingCharacters
    UndoCommand
    ViewOnlyMode
    Warnings
    WhatIsJot
    WindowHeader
    WordWrap
    XWindowsCutbuffer

This file belongs in /usr/local/doc/jot.doc.  Remember
that this is just on-line help; there's a more complete jot
reference guide available with the Insight reader.

Notation:

In this file, <A-x> means "Hold down the left Alt key and
type an x".  <A-X> means to hold down both the left Alt and
shift keys while you type x.  C stands for the control
key, and S for the shift key.  <A-C-S-rightmouse> would
mean to hold down Alt, Control, and Shift when you
press the right mouse button.

WhatIsJot?

Jot is a mouse-based cut-and-paste text editor that is
very fast, has a Showcase like user interface with the
addition of a set of keyboard commands that emulate
many default EMACS commands.  There are a lot of
speed-key commands.  It was originally written by Tom
Davis, with moral support from Derrick Burns, and was
called "zip".  All the bugs are due to Tom.  Chris
Eveland helped to convert it to the standard Silicon
Graphics look and feel.

Jot does no automatic line breaking, but the window
can be reshaped to see longer lines, the right mouse
with the control and alt buttons pans the view, and
<A-C-rightarrow> and <A-C-leftarrow> scroll right and
left.

You can use jot to look at arbitrary binary files, and
characters other than the standard ASCII characters are
represented as a special character that looks like a box
with an 'x' in it, followed by two hex digits.  Of
course, since lines aren't broken automatically, it may
be hard to see the ends of such lines.

StartupFlags:

jot [-fvxM [-p xmin,xmax,ymin,ymax] \
        [-l linenumber | +linenumber] [file ...]

If you don't give a file name, and there is no file in
the current directory named ".jotcruftXXX" (where XXX
is your user id), jot will use the name
"default.jot".  If the file .jotcruft appears, jot
will read that file and restore the open file and
reopen list exactly as it was the last time you edited
in that directory.  The restoration behavior can be
disabled by including the line "nojotcruft" in your
.jotrc file.  The "-f" option runs jot in the
foreground.  The "-p" option sets the window position
in screen coordinates.  It overrides the settings (if
any) in your .jotrc file.  If you give multiple file
names, jot visits the first, and the remaining files
are put on the file cycle list whose use is documented
in the section of "Dialog Boxes", below.  Jot
understands your shell's special characters (such as
*, ~, ?, ...) in filenames.

The "-v" option invokes jot in viewing only mode.
(Read-only files are opened in viewing only mode.)

If you want to be able to place the jot window with the
mouse rather than have it placed automatically, use the
-p option, but make xmin and ymin negative.  You have
to put in values for xmax and ymax, but they are
ignored.  xmin and ymin will be interpreted as the
negatives of the window size.  Thus to make a window
that is 600 by 800 pixels that is placed with the
mouse, use the command line:

jot -p -600,0,-800,0

The -l option lets you give the line number of the file
that will appear at the top of the jot window. If this
option is specified as "+linenumber", it must be
specified after all the other options and before the
first filename.

The -M (mmap) option tells jot to mmap() the file.  This
will be faster, but if another process touches the file
while jot is using it, jot may crash.  The -M flag is
particularly useful for editing giant files.

The -x option overrides making backup and checkpoint files.
This is useful when using jot as your mail or news editor.

TwoWindows:

If you want to cut and paste between two files, open
two jot sessions, and cut from one and paste into the
other.  You might make a file like the following,
called 'jot2':

----------------
#! /bin/csh -f
jot -p500,1272,520,992 $argv[1]
jot -p500,1272,8,480 $argv[2]
----------------

and put it in your ~/bin.  Then use 'jot2 file1 file2'
and get two nicely-placed files.  See also the section
on splitting windows.

Use the left mouse button for selection, pull-down
menus, and scrolling, double click for word
select, and the right mouse + Alt + Ctrl for panning.

Warnings:

If you're editing a giant file, make sure there's room
for a copy of the file on your file system if you plan
to write it out.  Jot writes a copy, and then renames
it to the original file name.

Preferences:

(Backups, CheckpointFiles)

When it starts, jot looks for a file in your home
directory called ".jotrc".  Currently, this file can
contain any of the following 12 lines:

autoaddnewline
autoindent
autosavecount <count>
backups
colors <backcolor> <textcolor> <cursorcolor> <selectcolor>
commentcolumn <column>
cyclesearch
electriccmode
expertmenus
fontpath <absolute path>
hardtabsize <size>
incrsearch
jotcruft
leftscroll
linenumbers
locale <file>
mapkey <key> <meta> <cmd>
margin <rightmargin>
markcolor <color>
nobrowsegizmo
nocase
nopulldown
oldstyle
position <xmin> <xmax> <ymin> <ymax>
rightmousepan
tabsize <size>
undobuffersize <count>
wordwrap

The names in <> represent numbers or filenames; for position, they
are screen coordinates (with negative numbers being
interpreted as in the -p option), and for colors, they
are indices into the color map.  If a line with the
word "backups" appears in the profile, a backup file
(with extension ".bak" will be written before editing
starts.  The margin option sets the right margin for
paragraph reformatting.  Jot does not produce backup
files if it is in view only mode.

The option "nobrowsegizmo" causes jot never to try to use the
Showcase browse gizmo, even if it is installed.  If
"autoaddnewline" appears, jot will automatically add a
newline to the end of any file if the file does not end
in one already.  The number following "autosavecount"
is the number of keystrokes jot waits before writing
out a checkpoint version of the file being edited.  If
it is zero, no checkpoints will be made.  The checkpoint
files have the extension ".sav".  No checkpoint files
are written if jot is in viewing only mode.

"expertmenus" causes jot to use the complete menues by
default.

"locale" causes jot to use the named file for names in
pulldown menus, error messages, et cetera.

"oldstyle" causes jot to behave as much like the original
"zip" editor as possible.

"oldaccelerators" causes jot to use the emacs-like Alt
bases menu accelerators, instead of standard accelerators.

"rightmousepan" makes jot interpret the right mouse button
as panning, as opposed to the default pull-down menu.

"markcolor" sets the colors of the marks and of the
line numbers, if they're displayed.

"undobuffersize" can make a larger undo buffer.  It is
2000 by default.  "incrsearch" makes all searches and
reverse searches incremental.  See the section on
searching.

"wordwrap" causes jot to word-wrap long lines (longer
than the margin) if you are typing at the end of the
line.

"nopulldown" causes jot to come up without the
pull-down menu.

"tabsize" changes the advance caused by typing the <tab>
key.  The tabs in your file are still to multiples of 8,
but a tabsize other than 8 will cause the insertion of
the correct number of tabs and spaces to advance to the
next multiple of tabsize.  Any spaces before the cursor
are eliminated, if possible.

"hardtabsize" makes the tab characters in jot represent
some number other than 8 columns.  It affects tabsize in
the obvious way

"electriccmode" causes jot to behave differently in files
with suffixes ".c", ".h", ".C", ".c++", and ".C++".  See
the section on electric-c.

"fontpath" lets you specify an absolute path name for a
fixed pitch font for jot to use.  The X fonts are typically
kept in the directories /usr/lib/fmfonts, and in the
sub-directories of /usr/lib/X11/fonts.  Use a fixed pitch
font or the results will be unpredictable.  If the font is
compressed (has a ".Z" extension), omit the ".Z" in your
filename specification.

"commentcolumn" sets the column at which C comments will
be added by the <A-%> command.  The default is column 48.

"mapkey" lets you remap the commands to different keys.
See the end of this document for a list of allowable key
names, meta names, and command names.

"jotcruft" causes jot to try to write files with
the name ".jotcruftXXX" in the current directory that contain
information about the files being edited. (The XXX stands for
your user id.

"autoindent" causes jot to match the indentation of the
current line when the <Enter> key is pressed.  It is off by
default.  This mode can be toggled with <A-Y>.

"linenumbers" turns on line numbering by default.

"cyclesearch" turns on cycle file searching by default.
In this mode, searches run through all files in the reopen
buffer before failing.

"nocase" makes case-independent search the default.

WindowHeader:

If your window manager has a header line, it contains
the version number followed by the name of the file
jot thinks you're editing.  If the file name is
followed by an asterisk, it means that the file has
been modified since it was read.  If you are defining
a macro, or are in the middle of an incremental
search, or in view-only mode, that information is also
shown in the header.

DialogBoxes:

There are 4 kinds of dialog boxes; one displays a
message for a short time and disappears; another
requires a type-in followed by a carriage return, the
third is the replace box, where you've got to fill in a
search string, a replace string, and then click on the
appropriate button.  Finally, there is a box that asks
for confirmation of something, and you must answer
either 'yes' or 'no' by clicking in the appropriate
box.  Sometimes a dialog box appears with text in the
type-in fields.  That text can be modified, or typing
<C-u> deletes the text in the line.  If you want to
abort a command when a dialog box is up, type <C-u> and
<Enter>.  You can also type <A-v> to paste the
contents of the cut buffer into a text entry field.

If you type <Esc> while you are typing in a file name,
jot will attempt to do file name completion for UNIX
files and directories.

If the dialog box requires a "yes" or "no" answer, and
one of the boxes has a cross in it, typing <Enter> is
the same as pressing that button.

OpeningFiles:

To visit a new file, use the Open command.  If Showcase
is installed on your machine, it uses the Showcase file
browser to get the file name, unless you have
specifically turned it off in your .jotrc.  Otherwise, it
uses the re-open dialog box.  The re-open dialog box
presents a list of previously visited files and files on
the command line.  When there is more than one file on
this list, you are presented with the name of the next
unvisited file or the last file you visited.  <Enter>
goes to that file.  Any typing will throw away the
suggested name and replace it with your typing.  <A-o>
or <A-O> cycle through the list of other files you've
visited or specified on the command line.  When you
re-visit a file, jot will return you to the same view
(line and selection) you had previously.

You can also re-open previously visited files using the
ReOpen command in the File pull-down menu.  The roll-over
menu names the files; clicking on the menu entry opens
the previously-open file.

Cycle ReOpen <C-A-o> cycles though the previously open
files, visiting them one after the other.

You can remove a file name from the ReOpen list using the
Remove Buffer roll-over in the "File" pull-down menu.  This
is useful if you use the <A-O> shortcut to cycle through
file names, and you accidentally get a bad name in the
list.  You can also remove file names that you're unlikely
to visit in the session to speed up the search.

To open a new file without yet specifying its name, use
the New command in the File pull-down menu or <A-n>.

PullDownMenu:

The left mouse button brings up the pull-down menus if
it is pressed in the menu bar along the top of your
jot window.  Speed key alternatives (Accelerators)
appear at the right of the menu(when they exist).
Less-frequently used commands appear in the roll-over
sub-menus.

Accelerators

Jot uses now uses SGI standard menu accelerators
invoked with the Ctrl key.  If you'd like to use
the emacs-like accelerators invoked with the Alt
key, set "oldaccelerators" or "oldstyle" in your
.jotrc file

Selection:

Click the left mouse button to place the cursor, or press
down, sweep, and let up to select a region of text.  If,
during selection, the cursor is moved above, below, or to
the left or right of the window, the text scrolls, if it
can.

SelectWord:

Double click with the left mouse to select a word.  If
you hold down the left mouse after a double click
while you sweep, your selection is made up of words
rather than characters.  <C-leftmouse> selects lines.

Marks:

<A-M> sets a mark in a file, and <A-m> jumps to a mark.
If there is a command multiplier between 0 and 9 inclusive,
marks 0 though 9 are set or jumped to.  Without a command
multiplier, <A-M> and <A-m> refer to any mark.  The marks
move around appropriately with character insertion and
deletion.  Typing <A-m> repeatedly cycles through all
marks.  A command multiplier before <A-m> jumps to a
specific mark.

Marks are displayed as blue numbers in the scroll bar.

<C-A-m> deletes the mark with the lowest number.  If it is
preceded by a command multiplier, then that particular mark
is deleted.  <A-5><C-A-m> deletes mark 5, for example.

<S-rightmouse> in the scroll bar sets mark 0 at the current
cursor position.  Clicking <rightmouse> in the right scroll
bar jumps to the nearest mark to the cursor in the scroll bar.

ExtendSelection:

To extend a selection, hold the shift key down before you
press the left mouse button.  If a region of text is
selected, only the textpointer nearer the cursor will
move, so you can adjust just one end of the selection.
If you use the middle mouse in the same way, the
selection will be changed by words instead of by
characters.  Similarly for lines and paragraphs.

You can extend the selection to a pattern specified for
a search or regular expression search, both forward and
backward.  Whereas <A-f> searches and selects the match,
<A-e> extends the selection to the matched search string.
The correspondence between the search commands and
extend selection by search commands is:

    <A-f> corresponds to <A-e>
    <A-F>         <A-E>
    <C-A-f>         <A-C-e>
    <C-A-F>         <A-C-E>
    <A-b>         <A-C-b>
    <A-B>         <A-C-B>

<A-C-J> extends the selection to the end of the line number
given (linenumber can be given with the command multiplier).

ParenthesisMatching:

The commands <A-[> and <A-]> expand the currently-
selected region to the smallest enclosing balanced
bracketed region, where brackets are defined as '(',
')', '[', ']', '{', and '}'.  Repeated applications of
this operation increase the size of the selected
region.  If it is impossible to find an enclosing
region, the selection is unaffected.  For example, if
"ddd" is selected in the following line:

{ abc { def () a ( [ ddd ] [ fg ] ) {} } },

then repeated applications will select the following
regions:

[ ddd ]
( [ ddd ] [ fg ] )
{ def () a ( [ ddd ] [ fg ] ) {} }
{ abc { def () a ( [ ddd ] [ fg ] ) {} } }

If a single bracket character (any of the 6) is selected,
the command simply selects the matching one.

If you're viewing this file in jot, try out various
initial selections.  If the brackets in the file don't
match, the results are hard to describe.

Editing:
CutCopyPaste:
DragSelection:

Cut and Copy in the pull-down menu manipulate the selected
region, and both place a copy in the cut buffer.  Paste
replaces the content of the selected region with the
contents of the cut buffer.  The cut buffer is kept in
the file /tmp/.cutbuffer, so that you can cut and paste
between two jot sessions.  It doesn't work between the shell
windows and jot, but you can use the X mechanism for that.

There's a shortcut for a copy-paste or a cut-paste
operation.  <C-rightmouse> copies the selection into
the cutbuffer, and pastes it where ever the cursor is
when the mouse button is released.  <S-rightmouse> does
the same thing, but cuts the selection instead.

XWindowsCutbuffer:

XCut, XCopy, and XPaste cut, copy, and paste to the X
cut buffer when running X windows on software release
4.0 or later.  The X cutbuffer is independent of jot's
regular cut buffer.  Whenever you make a selection in
jot, the selection is made the current X selection, and
can be used by other processes that use the X selection
mechanism.

ShowCutBuffer:

<A-S-.> displays the first few lines of the current
contents of the (non-X) cutbuffer.

AppendToCutBuffer:

You can append stuff to the cut buffer with the <A-z>
command.  It is just like copy, except that the text
selected is just appended to the current contents of
the cut buffer.

TypingCharacters:

Typed characters insert after the cursor, after deleting
the selected region.  Backspace (or the delete key)
deletes the selected region if it is non-empty, or
deletes the character before the cursor.  You can insert
any ascii character between (and including) <space> and
'~', newline, tab, or formfeed (<C-l>).

The <Delete> key is slightly different from the backspace
key.  If the character before the cursor is a tab, <Delete>
first converts the tab character to the appropriate number
of spaces, and then deletes one of those spaces.

ScrollingThroughText:

View different parts of the file using the left mouse
button in the scroll bar, or by clicking in the two boxes
at the bottom of the bar.  Holding the button down in the
two lower boxes causes the scroll to be continuous.  The
pink region in the scroll bar shows the selected region.

If you are scrolling and move the cursor more than 100
pixels outside the window, the scroll box jumps back to
the original position.

The arrow keys (in the cluster between the keyboard and
the numeric key pad) move you around in the file.  If the
<Ctrl> key is pressed when the right or left arrow key is
pressed, the cursor is moved by words.

LongLines:

The easiest way to pan left and right (and up and
down) is to use the right mouse button with the Alt
and Ctrl keys.  Press it down, move it, and release it
when you get the view you want.

For long lines, you can scroll left and right using the
<C-A-leftarrow> and <C-A-rightarrow> button combinations.

JumpToLineNumber:

The Jump command takes a line number from a dialog box,
and jumps to that line.  The first line in the file is
line 1.  There is a quick way to do this -- hold the
alt key down while you type the line number, and then,
with the alt key still down, type a 'j'.  See the
section on repeat counts, below.  You can also invoke
jot with the "-l" option to begin a session at a
particular line of a file.

Jump_to_column:

<A-C-j> works like jump to line, above.

ShowLineNumber:

To find the current line number, use <A-.>.  This will
display the line number, the current character position,
and the current column (which may be different, since
there may be tabs).

SearchingForText:
ReverseSearch:

The search command is case-dependent for the text
entered via the dialog box.  (The speed key for search
is <A-f>, <A-f> repeats the search for the same string,
and <A-F> == <A-S-F> asks for a new search string.)
The repeat search command checks to see if there is
some selected text on a single line.  If so, it
searches for that rather than the previous search
string.

The search mode can be toggled to case-independent with the
<A-y> command.

You can search in reverse in the same way with <A-B> (ask)
and <A-b> (don't ask for the search pattern unless it's
necessary).

In incremental search mode, each character you type
advances your selection in the buffer to the next
matching occurrence.  <backspace> undoes one step of
the incremental search.  <Esc>, <Enter>, or any other
command except repeat search gets you out of
incremental search mode.

Ctags

If you have used the UNIX ctags command to make a file called
tags in the current directory, jot can use this file with
the JumpToCtag command <A-J>.  It is like search in that
it uses the selected word, or if there is no selection, it
asks for the function name.  You will be deposited in the
correct file on the correct line.

QueryReplace:

The Paste/Search command <A-g> does a Paste operation, and
then repeats the last search.  You can do query replace
with this.

RegularExpressions:

You can search for regular expressions that are restricted
to a single line using <C-A-f> (search) and <C-A-F>
(repeat search).

There is a Paste/RegExpSearch <C-A-g> command for regular
expressions that corresponds to the Paste/Search command
for normal search.

There's a regular expression replace command as well -- see
the reference manual.

BackwardTab:

<S-Tab> deletes white space before the cursor to the last
tab stop.

Indentation:

The Indent and Outdent commands indent (or outdent) the
selected set of lines by 4 characters.  Indent is
<A-i> and outdent is <A-I>.  If there is a command
multiplier, Indent and Outdent use that number as the
number of columns.

ChangingCase:

Lowercase and Uppercase convert the selected region to
lowercase or uppercase.  If no region is selected, a
select word is performed around the cursor first.  The
speed key combinations for changing case are <A-U>,
<A-L>, and <A-C>, for uppercase, lowercase, and
capitalize, respectively.

InsertingFiles:

The insert file command inserts the named file to replace
the selected region.  <C-I> is the speed key combination
to insert a file.  Insert file uses the browse gizmo
unless it is turned off in your .jotrc preferences file.

NonStandardCharacters:

Weird characters (unfortunately, including the
form-feed command) appear in your file as a box with an
'x' inside, followed by two hex digits representing the
ASCII value.  Weird characters can be typed in by using
a command multiplier followed by the <Esc> key.  Thus,
typing <A-8> <Esc> inserts an ASCII 8, or literal
backspace, into your file.  Weird characters can be
selected, cut, and pasted.  You can also enter weird
characters using the <C-v> literal escape.  The character
following a <C-v> is inserted in the file.  To insert
a backspace character, type <C-v><Backspace>.  If the
Alt key is held down while the second character is typed,
the high-order bit of the character is turned on.  Thus,
to insert a 0x82 (= high bit + control-B), type:
<C-v><A-C-b>.  To enter a control-V, type: <C-v><C-v>.

Non-standard characters except for nul (= 0x00) and the
newline character can be used in search or search/replace
patterns.  Unfortunately, they just show up as the
"*" character in the dialog boxes.

ReformattingParagraphs:

The reformat command reformats all selected paragraphs
(determined by having 2 newlines in a row) to 72
columns.  It just uses the UNIX command fmt.  Use the
"margin" option in your .jotrc to change the number of
columns.

SearchAndReplace:

The replace command replaces all occurrences of the
searched-for string by the replacement string from the
cursor to the end of the file.  Any occurrences of the
search string above the cursor are not modified.
Replacement is always case-sensitive.  After specifying
the search or replace string, you can click with the
mouse in the other string or or type return to edit the
next string.  If you are editing the replacement string
return is the same as the "Do It" button.  The <Esc>
key aborts.  The only editing commands are typing
characters, backspace, and <C-u> (delete line).
Replacing something with nothing is legal; be careful.
Replacing nothing with something is not.

There is a version of the replace command suitable for
macros invoked by <C-R>.  After you type <C-R>, type
the contents of the replacement string terminated by a
newline.  The replacement will then take place, using
the previous search string as the string to be replaced.

The replace command can be bounded to the current selection
with the bounded replace command <C-R>.

Regular expression replace is <C-A-r>.  The search string
is a regular expression with (possibly) parts of the
pattern in parentheses followed by $#, where # is between
0 and 9.  Then if $# appears in the replace string, the
matching part of the search string is substituted for it.
Use '\' to literal escape the $ character in replace
strings.

Bounded regular expression replace is invoked with <C-A-R>.

SearchMultipleFiles:

Toggle on cycle file search using the Misc pulldown menu,
and searches (and search+paste commands) will not fail until
they have searched through all the files in the reopen
buffer.

WordWrap:

If word wrap is turned on, either from the .jotrc file,
or using <A-w>, newlines are automatically added to
lines if you type past the margin at the end of the
line.  The newlines replace the best possible space
(that nearest to, yet before, the margin.  <A-w>
toggles word wrap on and off.

LineNumbers:

<C-A-l> toggles the display of line numbers in blue at
the left edge of the screen.  At present, jot will only
do this correctly for files with fewer than 100000 lines.

Filters:

A command similar to the search command is the filter
command.  It applies an arbitrary shell filter to the
selected text, and returns the results to the cutbuffer
Invoke it with <A-P>.

If you want to return the results of the filter to the
shell instead of the cutbuffer, use <C-A-P>.

FilterExamples:

"sort" is a useful filter, but be sure to select
complete lines.

"spell" puts a list of suspected misspellings into the
cut buffer.  Be sure that your selection of text ends
with a newline, or spell will fail.

You can use filters like "date" that simply insert data
into the file.  You probably want an empty selection
before you do this.

"tee" can be used to save selected portions of text to a
file (use the filter command "tee filename").

"fmt" can be used directly for reformatting regions of
text to different margins, rather than messing around
with the margin option (use "fmt -40" for 40 column
formatting).

"cb" invokes the C beautifier on C source code.  You
probably want to do a "Select All" first.

"lp" prints the selected text.

"tr" may be useful.

"bc" will evaluate an expression if you remember to send
along a trailing newline.

"/bin/mail" will send selected text to somebody; for
example, type in "bin/mail davis" for your filter.

Remember that if you screw up, undo is available.

There is a command <A-C-p> that uses the contents of the
cutbuffer for the name of the filter.  This is suitable
for using filters in macros.

Macros:

To define a macro, hold down the Ctrl key and type one
of the keys F1 - F12 above the main keyboard.  Any keys
you type will then be included in the macro.  To end
the macro definition, hold down Ctrl, and type the same
key.

To invoke your macro, simply type the key (without the
Ctrl button).  Macros can only be made up of keystrokes
and repeat counts; no mouse selections.  Macros can call
each other, but not circularly.  There is a limit of
about 400 keystrokes in a macro definition.

To save your current set of macros, use the <C-A-M>
command.  The macros are saved in a file called
~/.jotmacs which is read every time you enter jot.

See the section on filters to learn how to use a filter
command from the cutbuffer in a macro.

You can get the current file name using <A-#>.  This is
sometimes useful in macro definition.

The commands <A-k>, <A-K>, and <C-A-k> (TPs to marks,
Marks to TPs, and Swap Marks and TPs,
respectively), are good for saving the selection during
a macro (especially when using a filter from the cutbuffer).
The marks used are the two most recently set.

UndoCommand:

Undo can undo a series of operations -- as many as will
fit in the undo buffer.  Typically, commands fill from
1 to 4 slots each, depending on how complicated they
are.  Replace to end of file can use a lot.  The buffer
has 2000 slots, and that is the limit on how far you
can back up.  You can change this constant from 2000
using the "undobuffersize" option in your .jotrc
file.  The only operations that cannot be undone are
file reads.  If you undo past a "Save" command, you will
be warned that the file on your disk has changes beyond
those reflected in your buffer.  It's up to you to take
appropriate action.

RedoCommand:

The Redo command undoes the operation of the Undo command.
You can redo any number of undo operations.

RepeatLastCommand:

The <Insert> key re-types the last sequence of characters
you typed, including the backspace key, so if you type
"<Backspace><Backspace>ABC", and then move the cursor and
type the <Insert> key, the two characters before the cursor
will be replaced by "ABC".  It also remembers the <C-D> and
<A-Backspace> commands.

RepeatCounts:

Most of the jot commands can be prefixed with a repeat
count.  This can be done by holding down the alt key
and typing a number.  For example, if you type <A-8>
and then the character x, 8 x's will be inserted in
your file at that point.  Multi-digit numbers are fine
-- just hold down the alt key for all the digits.  For
example, "<A-7> <A-7> <A-l>" will select 77 lines
in your file, but "<A-7> 7 <A-l>" will insert 7 7's
and select the one line.

If you don't prefix a command with a repeat count, the
repeat count is assumed to be 1.

For most commands, the numeric prefix has an obvious
meaning -- do the next thing that many times.

For many commands, the prefix makes no sense -- save file,
visit file, quit, and many others.

The file prefix has a special meaning in two cases:
reformat region and indent (or outdent).  For reformat
region, the prefix is the number of columns to use for
reformatting, and overrides the default.  If the repeat
count is 1, the default margin is used.  For
indentation, the count is used for the number of
columns to indent (or outdent).  If the repeat count is
1, indentation (outdentation) is set to 4 columns.

Basically any command resets the repeat count to 1.  If
you accidentally type the wrong number, just click with
the mouse on top of the cursor to reset the count.

ElectricCMode:

In this mode (entered via the "Misc" pull-down menu,
or via a setting in your .jotrc file), jot interprets
the <Enter> key differently. It also flashes balancing
parentheses, brackets, and braces when the closing one
is typed.  The tab size is set to 4, and when you type
a comma, a space is automatically added after the
comma.  Unless you manually turn it on from the
pull-down menu, it only takes effect in files with
suffixes of ".c", ".h", ".l", ".y", ".c++", ".C++",
and ".C".

If you wish to type one of the above electric characters
without special effects in electric-C mode, hold down the
<Ctrl> key while you type the character.

In electric-C mode, jot tries to notice when you are
typing a block comment and to handle the asterisks and
indentation properly.  Thus if your cursor is at the
end of the second line below:

    /* This is the start
     * of a multi-line comment
     */

and you press the <Enter> and the 'x' key, your cursor
will be placed at the end of the third line below:

    /* This is the start
     * of a multi-line comment
     * x
     */

(The x above illustrates that a trailing space is added.)

In addition, in electric-C mode, the characters that
make up a word differ slightly from those in normal
typing.  For example, the '_' character is part of a
word in electric-C mode.

<A-%> inserts a C comment at the end of the current line.
Jot advances to the comment column with tabs and spaces,
or, if the line extends beyond the comment column, jot
adds a single tab at the end of the line, and then adds
the comment.  The comment column is 48, and can be
changed in your .jotrc file.

SplitWindow:

The command <A-V> (Split windows in the "Misc"
pull-down menu) runs a new copy of jot on the same
file you are viewing.  Both windows are half the size
of the original, and the lower window is opened in
view-only mode.  There is a command in the "Misc"
window to toggle out of view- only mode, but beware --
the two jots that are running are completely
independent, and neither one knows about changes made
in the other.

The new window inherits the reopen file list from the
parent window.

ViewOnlyMode:

Jot can be invoked in view-only mode by starting it up with
the "-v" flag, or it can be put in that mode using the
ToggleViewOnly command under the "Misc" pull-down.  In this
mode, you cannot modify the buffer.  You can toggle in and
out of the mode using the pull-down menu entry.

Tutorial:

You can get the "Jot Tutorial for Non-Morons" via the
Help pull-down menu.  It works just like the help
command.  Read the tutorial in the tutorial window,
and try things out in the regular jot window.  The
tutorial file should be in /usr/local/doc/jot.tutorial.

SpeedKeys:

Following is a table of the speed key commands.  THERE IS
A DIFFERENCE BETWEEN UPPERCASE AND LOWERCASE LETTERS.  In
the table, <C-A> stands for <C-S-A>, <C-a> for
<C-a> (no shift), etc.

Command                   Speed-key(s)

Help (show this file)        <A-h>
Undo                <A-u>
Redo                <A-r>
Repeat last command        <Insert>
Quit                <A-q>
Quit no matter what        <A-Q>

Select all            <A-a>
Select bracketed region        <A-[> or <A-]>
Select word            <double-leftmouse>
Select line            <A-l> or <C-leftmouse>
Select paragraph        <A-p> or <C-double-leftmouse>
Extend selection        <S-leftmouse>
Extend selection word        <S-double-leftmouse>
Extend selection line        <C-S-middlemouse>
Extend selection paragraph    <C-S-leftmouse>

Extend selection right        <S-rightarrow>
Extend selection left        <S-leftarrow>
Extend selection right word    <S-C-rightarrow>
Extend selection left word    <S-C-leftarrow>
Extend selection to EOL        <S-A-rightarrow>
Extend selection to BOL        <S-A-leftarrow>
Extend selection up line    <S-uparrow>
Extend selection down line    <S-downarrow>
Extend selection up paragraph    <S-C-uparrow>
Extend selection down paragraph    <S-C-downarrow>
Extend selection to top of file    <S-A-uparrow>
Extend selection to end of file    <S-A-downarrow>

Set mark            <A-M>
Jump to mark            <A-m>
Delete mark            <A-C-m>
TPs to marks            <A-k>
Marks to TPs            <A-K>
Swap marks and TPs        <C-A-k>
Jump to ctag            <A-J>

Cut region to cutbuffer        <A-x>
Copy region to cutbuffer    <A-c>
Paste cutbuffer            <A-v>
Paste/Search            <A-g>
Paste/Reg Exp Search        <C-A-g>
Append to cutbuffer        <A-z>
Cut region to X cutbuffer    <C-A-x>
Copy region to X cutbuffer    <C-A-c>
Paste X cutbuffer        <C-A-v>

Forward search            <C-S> or <A-f>
Extend select search        <A-e>
Forward search (new string)    <C-s> or <A-F>
Extend select srch (new string)    <A-E>
Reverse search            <A-b>
Extnd sel rev search        <A-C-b>
Reverse search (new string)    <A-B>
Ext sel rev srch (new string)    <A-C-B>
Regular expression (regex) srch    <C-A-f>
Ext sel regex srch        <C-A-e>
Regex search (new string)    <C-A-F>
Ext sel regex srch (new string) <C-A-E>
Replace to end of file        <C-r>
Bounded replace            <C-R>
Keyboard replace        <C-A-w>
Regular expression replace    <C-A-r>
Bounded regex replace        <C-A-R>
Toggle search case        <A-y>

Save file            <A-s>
Save and quit            <C-A-S>
Save as file            <A-S>
Open file            <A-o>
ReOpen file            <A-O>
Cycle ReOpen file        <C-A-o>
New file            <A-n>
Save macro defs            <A-C-M>

Scroll right            <A-C-rightarrow>
Scroll left            <A-C-leftarrow>
Scroll up            <A-C-uparrow>
Scroll down            <A-C-downarrow>
Pan                <rightmouse>
Copy and drop            <C-rightmouse>
Drag and drop            <S-rightmouse>
Move to beginning of file    <Home> or <A-uparrow>
Move to end of file        <End> or <A-downarrow>
Move to beginning of selection    <A-Home>
Move to end of selection    <A-End>
Up a page            <PageUp>
Down a page            <PageDown>
Up half a page            <C-PageUp>
Down half a page        <C-PageDown>

Move forward a character    <C-f> or <rightarrow>
Move back a character        <C-b> or <leftarrow>
Move forward word        <C-rightarrow>
Move back word            <C-leftarrow>
Move to beginning of line    <C-a> or <A-leftarrow>
Move to end of line        <C-e> or <A-rightarrow>
Move to previous line        <C-p> or <uparrow>
Move to next line        <C-n> or <downarrow>
Move to end of paragraph    <C-downarrow>
Move to start of paragraph    <C-uparrow>
Jump to and select line        <A-j>

Newline plus indent        <C-j>
Transpose characters        <C-t>
Center selected lines        <C-c>
Delete next character        <C-d>
Kill to end of line        <C-k>
Kill to end of word        <A-d>
Kill to beginning of word    <A-Backspace>
Kill to beginning of line    <C-u>
Open new line after cursor    <C-o>
Open new line before cursor    <C-O>
Backward tab            <S-Tab>
Insert C comment        <A-%>

Apply filter            <A-P>
Filter with cutbuffer        <A-C-p>
To lowercase            <A-L>
To uppercase            <A-U>
Capitalize word (region)    <A-C>
Indent region 4 spaces        <A-i>
Outdent region 4 spaces        <A-I>
Reformat paragraphs        <A-R>
Begin/end macro def        <C-F*>    (1 <= * <= 12)
Call macro            <F*>    (1 <= * <= 12)
Toggle automatic indentation    <A-Y>
Toggle wordwrap            <A-w>
Toggle Electric-C mode        <A-C-W>
Toggle line numbers        <A-C-l>
Show line number        <A-.>
Show cut buffer            <A-S-.>
Insert file name        <A-S-#>
Toggle view only mode        <A-V>
Split window            <A-W>

Insert raw newline        <C-Enter>
Insert raw comma        <C-,>
Insert raw tab            <C-Tab>

CommandRemapping:

In the .jotrc file, you can include a line like:

mapkey VKEY CTRLSHIFT XPASTECMD

This will make <C-S-V> map to the X paste command.

You can customize your jot user interface with this
command.  Jot won't let you change the meanings of
the shift, ctrl, and alt keys, nor the meanings of
<A-0>, <A-1>, ..., <A-9>.  It's a bad idea to remap
the standard characters, since there's currently no
way to make some key combination send an "x", for
example.

The first entry after mapkey is the name of the key
as in /usr/include/device.h.  Do not use the names
like "BUT62"; use the names like "AKEY".  The second
entry is chosen from:

    NONE -- no meta keys
    SHIFT
    CTRL
    CTRLSHIFT
    ALT
    ALTSHIFT
    ALTCTRL
    ALTCTRLSHIFT

The final entry is a jot command name.  Here they are.  The
final name, ZERO, unmaps a key, so that pressing it causes
no command to be sent.

    APPENDTOBUFFERCMD - append selection to cut buffer
    ASKFILTERCMD - get a filter to apply to the selection
    ASKREGEXSEARCHCMD - regular expression search
    ASKREVSEARCHCMD - reverse search
    ASKSEARCHCMD - forward search
    ASKSHELLFILTERCMD - filter; results to shell
    BACKSPACECMD - backspace
    BACKSPACENUKECMD - backspace hacking tabs to spaces
    BACKTABCMD - backward tab
    BACKWORDCMD - move the cursor back a word
    BEGINFILECMD - jump to the beginning of the file
    BEGINLINECMD - move cursor to the beginning of the line
    BOUNDEDREPLACECMD - replace only in current selection
    BOUNDEDREGEXREPLACECMD - bounded regular expression replace
    CALLF10MACROCMD - call macro F10
    CALLF11MACROCMD - call macro F11
    CALLF12MACROCMD - call macro F12
    CALLF1MACROCMD - call macro F1
    CALLF2MACROCMD - call macro F2
    CALLF3MACROCMD - call macro F3
    CALLF4MACROCMD - call macro F4
    CALLF5MACROCMD - call macro F5
    CALLF6MACROCMD - call macro F6
    CALLF7MACROCMD - call macro F7
    CALLF8MACROCMD - call macro F8
    CALLF9MACROCMD - call macro F9
    CENTERLINECMD - center selected lines
    COPYCMD - copy selection to cut buffer
    CRAFTERCURSORCMD - add newline after the cursor
    CURSORDOWNCMD - move cursor down a line
    CURSORLEFTCMD - move cursor left a character
    CURSORRIGHTCMD - move cursor right a character
    CURSORUPCMD - move cursor up a line
    CUTBUFFILTERCMD - use the cut buffer as a filter
    CUTCMD - cut selection into cut buffer
    CYCLEFILECMD - cycle to next file
    CYCLESEARCHCMD - cycle through files on search
    DEFF10MACROCMD - define macro F10
    DEFF11MACROCMD - define macro F11
    DEFF12MACROCMD - define macro F12
    DEFF1MACROCMD - define macro F1
    DEFF2MACROCMD - define macro F2
    DEFF3MACROCMD - define macro F3
    DEFF4MACROCMD - define macro F4
    DEFF5MACROCMD - define macro F5
    DEFF6MACROCMD - define macro F6
    DEFF7MACROCMD - define macro F7
    DEFF8MACROCMD - define macro F8
    DEFF9MACROCMD - define macro F9
    DELETEMARKCMD - delete mark
    DELETENEXTCHARCMD - delete character after cursor
    DOWNPARAGRAPHCMD- move cursor down a paragraph
    ELECTRICCOMMENTCMD - add a C comment
    ENDFILECMD - jump to the end of the file
    ENDLINECMD - move cursor to the end of the line
    ESASKSEARCHCMD - extend selection to search string
    ESASKREGEXSEARCHCMD - extend selection to regex string
    ESASKREVSEARCHCMD - extend selection to reverse search
    ESBACKWORDCMD - extend selection back a word
    ESBEGINFILECMD - extend selection to top of file
    ESBEGINLINECMD - extend selection to beginning of line
    ESCURSORDOWNCMD - extend selection down a line
    ESCURSORLEFTCMD - extend selection left a character
    ESCURSORRIGHTCMD - extend selection right a character
    ESCURSORUPCMD - extend selection up a line
    ESDELETENEXTCHARCMD - delete selection plus next character
    ESDOWNPARAGRAPHCMD - extend selection to end of paragraph
    ESENDFILECMD - extend selection to the end of the file
    ESENDLINECMD - extend selection to the end of the line
    ESFWDWORDCMD - extend selection to next word
    ESGOTOLINECMD - extend selection to given line number
    ESREGEXSEARCHCMD - extend selection to regex search
    ESREVSEARCHCMD - extend selection to reverse search
    ESSEARCHCMD - extend selection to search string
    ESUPPARAGRAPHCMD - extend selection up a paragraph
    FIRSTUPPERCMD - first character in selection to uppercase
    FWDWORDCMD - move cursor forward a word
    GETLINERANGE - display the range of the selection
    GOTOCOLUMNCMD - go to column
    GOTOLINECMD - go to line
    GOTOMARKCMD - go to mark
    HALFPAGEDOWNCMD - go down half a page
    HALFPAGEUPCMD - go up half a page
    HELPCMD - display help
    INDENTCMD - indent selected lines
    INDENTNEWCMD - insert newline with indentation
    INSERTBRACECMD - insert the '{' character
    INSERTFILECMD - insert the contents of a file
    INSERTFILENAMECMD - insert the name of this file as text
    INSERTRAWNEWLINECMD - insert a newline character
    INSERTTABCMD - insert a tab character
    JUMPTOTAGCMD - jump to tag
    KBDREPLACECMD - replace command
    KILLBACKWORDCMD - kill word before cursor
    KILLTOBGNLINECMD - kill to beginning of line
    KILLTOEOLCMD - kill to end of line
    KILLWORDCMD - kill the next word
    LITERALESCAPE - use command count as ascii character
    MARKSTOTPSCMD - put marks 8, 9 into text pointers
    NEWFILECMD - visit a new file
    OPENCMD - open a file
    OPENLINECMD - open a line after the cursor
    OPENPREVLINECMD - open a line before the cursor
    OUTDENTCMD - take away indentation from selected lines
    PAGEDOWNCMD - move down a screenful
    PAGEUPCMD - move up a screenful
    PARENMATCHCMD - select text enclosed in parentheses
    PASTEANDREGEXCMD - paste and repeat regular exp search
    PASTECMD - paste contents of cut buffer
    PASTENSEARCHCMD - paste and repeat search
    QUITCMD - quit
    QUITDAMMITCMD - quit without asking about dirty files
    REDOCMD - redo command
    REFORMATREGIONCMD - reformat the selected region
    REGEXREPLACECMD - regular expression replace
    REGEXSEARCHCMD - regular expression search
    REOPENCMD - reopen a previously visited file
    REPEATCMDCMD - repeat the last typein
    REPLACECMD - replace command
    REVSEARCHCMD - search backwards
    SAVEASCMD - save the buffer as a file with a new name
    SAVECMD - save the buffer
    SAVEMACRODEFSCMD - write out macro definitions
    SAVEQUITCMD - save the file and quit
    SCROLLDOWNCMD - scroll down
    SCROLLLEFTCMD - scroll left
    SCROLLRIGHTCMD - scroll right
    SCROLLUPCMD - scroll up
    SEARCHCMD - search command
    SELECTALLCMD - select entire buffer
    SELECTLINECMD - select the line
    SELECTPARAGRAPHCMD - select the paragraph
    SETMARKCMD - set a mark at the cursor
    SHOWCUTBUFCMD - show the contents of the cutbuffer
    SWAPMARKSTPSCMD - swap marks 8,9 with textpointers
    TOBEGINFILECMD - view beginning of file
    TOENDFILECMD - view end of file
    TOGGLEAUTOINDENTCMD - toggle automatic indentation
    TOGGLECASECMD - toggle whether search is case-dependent
    TOGGLENUMBERSCMD - toggle the display of line numbers
    TOGGLEELECCCMD - toggle to/from electric-C mode
    TOGGLEVIEWONLYCMD - toggle in/out of view-only mode
    TOGGLEWORDWRAPCMD - toggle word-wrap mode
    TOLOWERCMD - convert to lower case
    TOTP1CMD - view the first text pointer
    TOTP2CMD - view the last text pointer
    TOUPPERCMD - convert to upper case
    TPSTOMARKSCMD - put the text pointers into marks 8,9
    TRANSPOSECMD - transpose characters
    TUTORIALCMD - run the tutorial
    UNDOCMD - undo the last command
    UPPARAGRAPHCMD - move up a paragraph
    WINSPLITCMD - split window horizontally
    XCOPYCMD - copy to X cut buffer
    XCUTCMD - cut to X cut buffer
    XPASTECMD - paste from X cut buffer
    ZERO - disable normal action of this key